#pragma once

#include <vector>
#include <unordered_map>
#include <memory>
#include <functional>
#include <chrono>  // 添加chrono头文件
#include "viml/value.h"
#include "viml/instruction.h"
#include "viml/memory_manager.h"
#include "viml/vm_memoization.h"  // 第二阶段优化：记忆化支持
#include "viml/scope_manager.h"  // 作用域管理器
#include "viml/debug_info.h"     // 调试信息管理

namespace viml {

// 前向声明
class Debugger;

// 虚拟机异常类
class VMException : public std::exception {
private:
    std::string message;
    size_t pc;
    std::string function_name;

public:
    VMException(const std::string& msg, size_t program_counter = 0, 
                const std::string& func_name = "")
        : message(msg), pc(program_counter), function_name(func_name) {}

    const char* what() const noexcept override { return message.c_str(); }
    size_t get_pc() const { return pc; }
    const std::string& get_function_name() const { return function_name; }
    
    std::string format_error() const;
};

// 循环超时异常类
class LoopTimeoutException : public VMException {
public:
    LoopTimeoutException(const std::string& message, size_t pc, const std::string& function_name)
        : VMException(message, pc, function_name) {}
};

/**
 * 调用栈帧
 */
struct CallFrame {
    size_t pc;                          // 程序计数器
    size_t base_register;               // 基址寄存器索引
    size_t return_address;              // 返回地址
    std::shared_ptr<Bytecode> bytecode; // 当前执行的字节码
    std::string function_name;          // 函数名（调试用）
    size_t result_register;             // 返回值寄存器
    std::vector<Value> saved_registers; // 保存的寄存器状态
    size_t saved_register_count;        // 保存的寄存器数量
    
    // 第二阶段优化：记忆化支持
    std::vector<Value> function_arguments;  // 保存原始函数参数用于记忆化
    bool should_memoize = false;             // 是否需要记忆化
    
    CallFrame() = default;
    CallFrame(size_t program_counter, size_t base_reg, size_t ret_addr,
              std::shared_ptr<Bytecode> code, const std::string& name = "")
        : pc(program_counter), base_register(base_reg), return_address(ret_addr),
          bytecode(code), function_name(name), result_register(0), saved_register_count(0) {}
};

/**
 * 虚拟机执行状态
 */
enum class VMState {
    READY,      // 准备就绪
    RUNNING,    // 正在执行
    PAUSED,     // 暂停（调试）
    HALTED,     // 已停止
    ERROR       // 错误状态
};

/**
 * VimL虚拟机
 */
class VM {
private:
    // 执行状态
    VMState state;
    
    // 寄存器数组（最大256个寄存器）
    std::vector<Value> registers;
    
    // 调用栈
    std::vector<CallFrame> call_stack;
    
    // 全局变量（徃用，保留以保持向后兼容）
    std::unordered_map<std::string, Value> globals;
    
    // 作用域管理器
    std::unique_ptr<ScopeManager> scope_manager;
    
    // 当前执行上下文
    std::shared_ptr<Bytecode> current_bytecode;
    size_t pc;  // 程序计数器
    
    // 调试支持
    bool debug_mode;
    std::shared_ptr<Debugger> debugger;
    
    // 循环延迟和超时配置
    bool loop_delay_enabled;
    int loop_delay_ms;
    int loop_timeout_ms;
    bool infinite_loop_detection_enabled;
    size_t max_loop_iterations;
    
    // 循环执行跟踪（用于无限循环检测）
    std::chrono::steady_clock::time_point loop_start_time;
    size_t loop_iteration_count;
    
    // 内置函数映射
    std::unordered_map<std::string, std::function<Value(const std::vector<Value>&)>> builtins;
    
    // 第二阶段优化：记忆化管理器
    MemoizationManager memoization_manager;

public:
    VM();
    ~VM() = default;

    // 禁用拷贝构造和赋值
    VM(const VM&) = delete;
    VM& operator=(const VM&) = delete;

    // 执行接口
    Value execute(std::shared_ptr<Bytecode> bytecode);
    void reset();
    void halt();

    // 状态查询
    VMState get_state() const { return state; }
    bool is_running() const { return state == VMState::RUNNING; }
    bool is_paused() const { return state == VMState::PAUSED; }
    bool is_halted() const { return state == VMState::HALTED; }

    // 调试支持
    void set_debug_mode(bool enabled) { debug_mode = enabled; }
    bool get_debug_mode() const { return debug_mode; }
    void set_debugger(std::shared_ptr<Debugger> dbg) { debugger = dbg; }
    std::shared_ptr<Debugger> get_debugger() const { return debugger; }
    bool has_debugger() const { return debugger != nullptr; }
    void pause() { if (state == VMState::RUNNING) state = VMState::PAUSED; }
    void resume() { if (state == VMState::PAUSED) state = VMState::RUNNING; }
    
    // 循环延迟和超时控制
    void set_debug_loop_delay(int milliseconds) { loop_delay_ms = milliseconds; }
    int get_debug_loop_delay() const { return loop_delay_ms; }
    void set_loop_timeout(int milliseconds) { loop_timeout_ms = milliseconds; }
    int get_loop_timeout() const { return loop_timeout_ms; }
    void enable_infinite_loop_detection(bool enable) { infinite_loop_detection_enabled = enable; }
    bool is_infinite_loop_detection_enabled() const { return infinite_loop_detection_enabled; }
    void set_loop_delay_enabled(bool enabled) { loop_delay_enabled = enabled; }
    bool is_loop_delay_enabled() const { return loop_delay_enabled; }
    void set_max_loop_iterations(size_t max_iterations) { max_loop_iterations = max_iterations; }
    size_t get_max_loop_iterations() const { return max_loop_iterations; }

    // 全局变量访问
    void set_global(const std::string& name, const Value& value);
    Value get_global(const std::string& name) const;
    bool has_global(const std::string& name) const;

    // 寄存器访问
    const Value& get_register(size_t index) const;
    void set_register(size_t index, const Value& value);
    size_t get_register_count() const { return registers.size(); }

    // 调用栈访问
    const std::vector<CallFrame>& get_call_stack() const { return call_stack; }
    size_t get_current_pc() const { return pc; }
    const std::string& get_current_function() const;
    int get_current_line() const;
    
    // 内置函数注册
    void register_builtin(const std::string& name, std::function<Value(const std::vector<Value>&)> func);
    
    // 优化项2：调试接口 - 变量查看功能
    std::unordered_map<std::string, Value> get_local_variables() const;
    std::unordered_map<std::string, Value> get_global_variables() const;
    Value get_variable(const std::string& name) const;
    std::unordered_map<size_t, Value> get_register_snapshot() const;
    
    // 作用域信息
    struct ScopeInfo {
        std::string scope_name;
        size_t depth;
        std::vector<std::string> variable_names;
    };
    ScopeInfo get_current_scope_info() const;
    
    // 第二阶段优化：记忆化管理接口
    void set_memoization_enabled(bool enabled) { memoization_manager.set_enabled(enabled); }
    bool is_memoization_enabled() const { return memoization_manager.is_enabled(); }
    void add_memoizable_function(const std::string& function_name) { 
        memoization_manager.add_memoizable_function(function_name); 
    }
    void remove_memoizable_function(const std::string& function_name) { 
        memoization_manager.remove_memoizable_function(function_name); 
    }
    void clear_memoization_cache() { memoization_manager.clear_cache(); }
    MemoizationCache::Statistics get_memoization_statistics() const { 
        return memoization_manager.get_cache_statistics(); 
    }
    void optimize_memoization_for_recursive_algorithms() { 
        memoization_manager.optimize_for_recursive_algorithms(); 
    }
    
    /**
     * 自动分析函数并添加到记忆化白名单（如果是纯函数）
     * @param func_stmt 函数声明语句
     * @return 分析结果
     */
    FunctionPurityAnalyzer::AnalysisResult analyze_and_add_function(FunctionStatement& func_stmt) {
        return memoization_manager.analyze_and_add_function(func_stmt);
    }

    // 统计信息
    struct Statistics {
        size_t instructions_executed = 0;
        size_t function_calls = 0;
        size_t memory_allocations = 0;
        double execution_time = 0.0;
    };
    
    const Statistics& get_statistics() const;
    void reset_statistics() { 
        stats = Statistics{}; 
        MemoryManager::reset_statistics(); // 重置内存管理器统计信息
    }

private:
    Statistics stats;

    // 核心执行方法
    void execute_instruction(const Instruction& inst);
    void call_function(size_t func_reg, size_t argc, size_t result_reg);
    void return_from_function(size_t start_reg, size_t count);
    
    // 指令实现
    void op_load_const(uint8_t reg, uint16_t const_idx);
    void op_load_nil(uint8_t reg);
    void op_load_true(uint8_t reg);
    void op_load_false(uint8_t reg);
    void op_move(uint8_t dst, uint8_t src);
    
    void op_load_global(uint8_t reg, uint16_t name_idx);
    void op_store_global(uint8_t reg, uint16_t name_idx);
    void op_load_local(uint8_t dst, uint8_t src);
    void op_store_local(uint8_t dst, uint8_t src);
    
    // 作用域操作
    void op_load_scope(uint8_t reg, uint8_t scope_id, uint16_t name_idx);
    void op_store_scope(uint8_t scope_id, uint16_t name_idx, uint8_t value_reg);
    
    void op_add(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_sub(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_mul(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_div(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_mod(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_neg(uint8_t dst, uint8_t src);
    
    void op_eq(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_ne(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_lt(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_le(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_gt(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_ge(uint8_t dst, uint8_t lhs, uint8_t rhs);
    
    void op_and(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_or(uint8_t dst, uint8_t lhs, uint8_t rhs);
    void op_not(uint8_t dst, uint8_t src);
    
    void op_jmp(int16_t offset);
    void op_jmp_if_true(uint8_t reg, int16_t offset);
    void op_jmp_if_false(uint8_t reg, int16_t offset);
    
    void op_iter_init(uint8_t iter_reg, uint8_t obj_reg);
    void op_iter_next(uint8_t iter_reg, int16_t end_offset);
    
    void op_new_list(uint8_t reg, uint8_t capacity);
    void op_new_dict(uint8_t reg);
    void op_get_index(uint8_t dst, uint8_t obj, uint8_t key);
    void op_set_index(uint8_t obj, uint8_t key, uint8_t value);
    void op_len(uint8_t dst, uint8_t obj);
    void op_list_append(uint8_t list, uint8_t value);
    void op_dict_set(uint8_t dict, uint8_t key, uint8_t value);
    
    void op_str_cat(uint8_t dst, uint8_t lhs, uint8_t rhs);
    
    void op_echo(uint8_t start, uint8_t count);
    void op_breakpoint();
    void op_dbg_line(uint16_t line);
    
    // 辅助方法
    void ensure_register_count(size_t count);
    void push_call_frame(const CallFrame& frame);
    CallFrame pop_call_frame();
    void check_register_bounds(size_t index) const;
    
    // 错误处理
    void runtime_error(const std::string& message);

    // 调试回调
    void debug_hook();
    void debug_line_hook(uint16_t line);
    void debug_call_hook(const std::string& function_name);
    void debug_return_hook();
    
    // 循环延迟和超时检查
    void check_loop_delay_and_timeout();
};

} // namespace viml